/**
 * ***************************************************************************** Copyright (c) 2005,
 * 2006 Subclipse project and others. All rights reserved. This program and the accompanying
 * materials are made available under the terms of the Eclipse Public License v1.0 which accompanies
 * this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html
 *
 * <p>Contributors: Subclipse project committers - initial API and implementation
 * ****************************************************************************
 */
package org.tigris.subversion.subclipse.ui.subscriber;

import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import org.eclipse.compare.structuremergeviewer.IDiffElement;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.dialogs.ProgressMonitorDialog;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.swt.custom.BusyIndicator;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.team.core.RepositoryProvider;
import org.eclipse.team.core.TeamException;
import org.eclipse.team.core.synchronize.SyncInfoSet;
import org.eclipse.team.ui.synchronize.ISynchronizePageConfiguration;
import org.eclipse.ui.actions.WorkspaceModifyOperation;
import org.tigris.subversion.subclipse.core.ISVNLocalResource;
import org.tigris.subversion.subclipse.core.SVNException;
import org.tigris.subversion.subclipse.core.SVNTeamProvider;
import org.tigris.subversion.subclipse.core.resources.SVNWorkspaceRoot;
import org.tigris.subversion.subclipse.ui.Policy;
import org.tigris.subversion.subclipse.ui.SVNUIPlugin;

public class AddSynchronizeOperation extends SVNSynchronizeOperation {
  private IResource[] resources;
  private boolean addIgnoredResources;

  public static final int PROGRESS_DIALOG = 1;
  public static final int PROGRESS_BUSYCURSOR = 2;

  public AddSynchronizeOperation(
      ISynchronizePageConfiguration configuration, IDiffElement[] elements) {
    super(configuration, elements);
  }

  protected boolean promptForConflictHandling(Shell shell, SyncInfoSet syncSet) {
    return true;
  }

  protected void run(SVNTeamProvider provider, SyncInfoSet set, IProgressMonitor monitor)
      throws InvocationTargetException, InterruptedException {
    resources = set.getResources();
    getShell()
        .getDisplay()
        .syncExec(
            new Runnable() {
              public void run() {
                addIgnoredResources = promptForAddOfIgnored(resources);
              }
            });
    if (!addIgnoredResources) return;
    run(
        new WorkspaceModifyOperation() {
          public void execute(IProgressMonitor monitor) throws InvocationTargetException {
            try {
              // associate the resources with their respective RepositoryProvider
              Hashtable table = getProviderMapping(resources);
              Set keySet = table.keySet();
              monitor.beginTask("", keySet.size() * 1000); // $NON-NLS-1$
              monitor.setTaskName(Policy.bind("AddAction.adding")); // $NON-NLS-1$
              Iterator iterator = keySet.iterator();
              while (iterator.hasNext()) {
                IProgressMonitor subMonitor = Policy.subMonitorFor(monitor, 1000);
                SVNTeamProvider provider = (SVNTeamProvider) iterator.next();
                List list = (List) table.get(provider);
                IResource[] providerResources =
                    (IResource[]) list.toArray(new IResource[list.size()]);
                provider.add(providerResources, IResource.DEPTH_INFINITE, subMonitor);
              }
            } catch (TeamException e) {
              throw new InvocationTargetException(e);
            } finally {
              monitor.done();
            }
          }
        },
        true /* cancelable */,
        PROGRESS_BUSYCURSOR);
  }

  private boolean promptForAddOfIgnored(IResource[] resources) {
    boolean prompt = false;
    for (int i = 0; i < resources.length; i++) {
      ISVNLocalResource resource = SVNWorkspaceRoot.getSVNResourceFor(resources[i]);
      try {
        if (resource.isIgnored()) {
          prompt = true;
          break;
        }
      } catch (SVNException e) {
        return false;
      }
    }
    if (prompt) {
      return MessageDialog.openQuestion(
          getShell(),
          Policy.bind("AddAction.addIgnoredTitle"),
          Policy.bind("AddAction.addIgnoredQuestion")); // $NON-NLS-1$ //$NON-NLS-2$
    }
    return true;
  }

  protected final void run(
      final IRunnableWithProgress runnable, boolean cancelable, int progressKind)
      throws InvocationTargetException, InterruptedException {
    final Exception[] exceptions = new Exception[] {null};

    // Ensure that no repository view refresh happens until after the action
    final IRunnableWithProgress innerRunnable =
        new IRunnableWithProgress() {
          public void run(IProgressMonitor monitor)
              throws InvocationTargetException, InterruptedException {
            SVNUIPlugin.getPlugin().getRepositoryManager().run(runnable, monitor);
          }
        };

    switch (progressKind) {
      case PROGRESS_BUSYCURSOR:
        BusyIndicator.showWhile(
            Display.getCurrent(),
            new Runnable() {
              public void run() {
                try {
                  innerRunnable.run(new NullProgressMonitor());
                } catch (InvocationTargetException e) {
                  exceptions[0] = e;
                } catch (InterruptedException e) {
                  exceptions[0] = e;
                }
              }
            });
        break;
      case PROGRESS_DIALOG:
      default:
        new ProgressMonitorDialog(getShell())
            .run(true, cancelable, /*cancelable, true, */ innerRunnable);
        break;
    }
    if (exceptions[0] != null) {
      if (exceptions[0] instanceof InvocationTargetException)
        throw (InvocationTargetException) exceptions[0];
      else throw (InterruptedException) exceptions[0];
    }
  }

  protected Hashtable getProviderMapping(IResource[] resources) {
    Hashtable result = new Hashtable();
    for (int i = 0; i < resources.length; i++) {
      RepositoryProvider provider = RepositoryProvider.getProvider(resources[i].getProject());
      List list = (List) result.get(provider);
      if (list == null) {
        list = new ArrayList();
        result.put(provider, list);
      }
      list.add(resources[i]);
    }
    return result;
  }
}
